BMUG Revelations/BMUG Revelations.toast/Utilities/Random/Commodore 64c/SOURCE/Serial.c

Text File | 1994-02-13 | 4KB | 186 lines

/*
    Commodore 64 Emulator v0.1      Earle F. Philhower III
    Copyright (C) 1993-4            ([e-mail])

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "Flags.h"
#include "Registers.h"
#include "Memory.h"
#include "Traps.h"
#include "Serial.h"
#include "Error.h"

typedef struct {
    byte inuse  : 1;
    byte isopen : 1;
    byte (*getf)(byte *, int);
    byte (*putf)(byte, int);
    byte (*openf)(char *, int, int);
    byte (*closef)(int);
    void (*flushf)(int);
} SerialType;
static SerialType device[16];

#define BUFFERLEN 127
static byte serialBuffer[BUFFERLEN];

static byte serialPtr, latestListen, trapListen, latestSaListen;

static void SerialSendByte(void), SerialRecieveByte(void), SerialListen(void),
            SerialSaListen(void), FloppyReadyTrap(void);
static byte SerialDummy(void);

static trap serialTrap[] = {
    { 0xed40, {0x78, 0x20, 0x97}, SerialSendByte },
    { 0xee13, {0x78, 0xa9, 0x00}, SerialRecieveByte },
    { 0xed0e, {0x20, 0xa4, 0xf0}, SerialListen },
    { 0xed36, {0x78, 0x20, 0x8e}, SerialSaListen },
    { 0xeea9, {0xad, 0x00, 0xdd}, FloppyReadyTrap } };

void SerialInitialize(void)
{
    byte i;
    SerialType *p;

    AddTrap(serialTrap[0]);
    AddTrap(serialTrap[1]);
    AddTrap(serialTrap[2]);
    AddTrap(serialTrap[3]);
    AddTrap(serialTrap[4]);

    for (i = 0; i < 16; i++) {
        p=&device[i];
        p->getf=(byte (*)(byte *, int ))SerialDummy;
        p->putf=(byte (*)(byte, int ))SerialDummy;
        p->openf=(byte (*)(char *, int , int ))SerialDummy;
        p->closef=(byte (*)(int ))SerialDummy;
        p->flushf=(void (*)(int ))NULL; }
}

void AddSerialDevice(int devnum, byte (*getf)(byte *, int),
    byte (*putf)(byte, int), byte (*openf)(char *, int, int),
    byte (*closef)(int), void (*flushf)(int))
{
    SerialType *p;

    if ((devnum<0)||(devnum>15)) InternalError(kInvalidDeviceNumber);
    p=&device[devnum];
    if (p->inuse!=0) InternalError(kDeviceNumberInUse);

    p->getf = getf;
    p->putf = putf;
    p->openf = openf;
    p->closef = closef;
    p->flushf = flushf;
    p->inuse = 1;
}


static void SerialSendByte(void)
{
    byte data;
    SerialType *p;
    extern void i60(void);

    data=RAM[0x95];
    p=&device[latestListen&0x0f];

    if (p->isopen==0) {
        if (serialPtr<BUFFERLEN) serialBuffer[serialPtr++] = data; }
    else (*p->putf)(data, latestSaListen & 0x0f);
    i60();    /* RTS */
}

static void SerialRecieveByte(void)
{
    byte pp;
    SerialType *p;
    extern void i60(void);

    p=&device[latestListen&0x0f];

    RAM[0x90]=(*p->getf)(&pp, latestSaListen&0x0f);
    RAM[0xa4]=a=pp;
    flags &= ~CAR;
    i60();    /* RTS */
}

static void SerialListen(void)
{
    extern void i60(void);

    trapListen=a;
    i60();    /* RTS */
}

static void SerialSaListen(void)
{
    SerialType *p;
    byte b, i;
    extern void i60(void);

    b=RAM[0x95];
    p=&device[latestListen&0x0f];

    if (b==0x3f)
        switch (latestSaListen&0xf0) {
            case 0xf0:
                 if (p->isopen==0) {
                    p->isopen=1;
                    i=(*p->openf)((char *)serialBuffer, serialPtr, latestSaListen&0x0f);
                    serialPtr=0;
                    RAM[0x90]=i;
                    if (i) {
                        p->isopen=0;
                        (*p->closef)(latestSaListen&0x0f); } }
                if (p->flushf) (*p->flushf)(latestSaListen&0x0f);
                break;
            case 0x60:
                if (p->isopen==0) {
                    p->isopen=1;
                    (*p->openf)(NULL, 0, latestSaListen&0x0f);
                    for (i=0; i<serialPtr; i++)
                        (*p->putf)(serialBuffer[i], latestSaListen&0x0f);
                    serialPtr=0; }
                if (p->flushf) (*p->flushf)(latestSaListen&0x0f);
                break;
            case 0xe0:
                p->isopen=0;
                (*p->closef)(latestSaListen&0x0f);
                break;
            default:
                DebugStr("\pUnimplemented Serial Command"); break;
            }

    latestListen=trapListen;
    latestSaListen=b;

    i60();    /* RTS */
}

static void FloppyReadyTrap(void)
{
    extern void i60(void);

    a = 0x01;
    flags &=(~NEG+ZER);
    i60();    /* RTS */
}



static byte SerialDummy(void) { return 2; }